Thread: Inheritence and operator[]

Hello, slight problem here.

I have two classes which look kinda like this:

Code:

class A {
	...

	public:
		T *operator[] (int);

	...
};

class B : public A {
	...
};

And a variable:

Code:

B x;

But when I try to do something like x[0] it returns an object of type B, not an object of type T.

Do I need to do something special to get it to return a T ?

What is T?

That doesn't make sense. Can you post a simple, compilable example that demonstrates the problem? If T is completely unrelated to B, I don't see how x[0] can return a B.

Originally Posted by Daved

That doesn't make sense. Can you post a simple, compilable example that demonstrates the problem? If T is completely unrelated to B, I don't see how x[0] can return a B.

Not sure if I got the psuedo in the original post correct, anyway, here's some code that dosn't compile:

Code:

#include <stdio.h>

template <typename T>
class A {
	public:
		char *operator[] (int);
};

template <typename T>
char *A<T>::operator[] (int i) {
	char *test = new char;
	
	*test = 'a';
	
	return test;
}

class C {
	/*...*/
};

class B : public A<C> {
};

int main() {
	B *x;
	char *y = x[0];
}

But if I change x[0] to (*x)[0] , then it compiles, go figure!

The problem is that x is a B*, not a B. When you use operator[] on a pointer, then the compiler will assume it is an array and do a normal array operation on it.

The reason (*x)[0] works is because you are dereferencing the pointer and therefore you are calling the object's operator[].